package com.gxc.string;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

/**
 * VLAN是一种对局域网设备进行逻辑划分的技术，为了标识不同的VLAN，引入VLAN ID(1-4094之间的整数)的概念。
 *
 * 定义一个VLAN ID的资源池(下称VLAN资源池)，资源池中连续的VLAN用开始VLAN-结束VLAN表示，不连续的用单个整数表示，所有的VLAN用英文逗号连接起来。
 *
 * 现在有一个VLAN资源池，业务需要从资源池中申请一个VLAN，需要你输出从VLAN资源池中移除申请的VLAN后的资源池。
 *
 * 输入描述
 * 第一行为字符串格式的VLAN资源池，第二行为业务要申请的VLAN，VLAN的取值范围为[1,4094]之间的整数。
 *
 * 输出描述
 * 从输入VLAN资源池中移除申请的VLAN后字符串格式的VLAN资源池，输出要求满足题目描述中的格式，并且按照VLAN从小到大升序输出。
 * 如果申请的VLAN不在原VLAN资源池内，输出原VLAN资源池升序排序后的字符串即可。
 */
public class VLAN {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String resource = scanner.nextLine();
        java.lang.Integer n = java.lang.Integer.parseInt(scanner.nextLine());

        List<java.lang.Integer> resourcePool = parseVlanPool(resource);
        Collections.sort(resourcePool);

        if (resourcePool.isEmpty()) return;
        if (n<resourcePool.get(0) || n>resourcePool.get(resourcePool.size()-1)) {
        } else {
            int i = 0;
            for (; i < resourcePool.size(); i++) {
                if (resourcePool.get(i).equals(n)) {
                    break;
                }
            }
            resourcePool.remove(i);
        }
        formatPool(resourcePool);
    }

    private static void formatPool(List<java.lang.Integer> resourcePool) {
        if (resourcePool.isEmpty()) return;

        StringBuilder builder = new StringBuilder();
        int i = 0;

        while (i<resourcePool.size()) {
            int cur = resourcePool.get(i);
            boolean continuous = false;
            builder.append(cur);
            i++;
            while (i<resourcePool.size() && cur+1 == resourcePool.get(i)) {
                cur = resourcePool.get(i);
                continuous = true;
                i++;
            }
            if (continuous) {
                builder.append("-").append(resourcePool.get(i-1));
            }
            builder.append(",");
        }
        System.out.println(builder.subSequence(0, builder.length()-1).toString());
    }

    private static List<java.lang.Integer> parseVlanPool(String resource) {
        List<java.lang.Integer> pool = new ArrayList<>();

        String[] split = resource.split(",");
        for (String str : split) {
            if (str.contains("-")) {
                String[] num = str.split("-");
                int s = java.lang.Integer.parseInt(num[0]);
                int e = java.lang.Integer.parseInt(num[1]);
                for (int i = s; i <= e; i++) {
                    pool.add(i);
                }
            } else {
                pool.add(java.lang.Integer.parseInt(str));
            }
        }
        return pool;
    }

    // 格式化VLAN资源池
    private static String formatVlanPool(List<java.lang.Integer> vlanPool) {
        StringBuilder result = new StringBuilder();
        java.lang.Integer last = null;
        for (int index = 0; index < vlanPool.size(); index++) {
            if (last == null) {
                // 如果是第一个VLAN，直接添加到结果中
                result.append(vlanPool.get(index));
                last = vlanPool.get(index);
            } else {
                if (vlanPool.get(index) - last == 1) {
                    // 如果与上一个VLAN相差1，表示是连续的VLAN
                    if (result.toString().endsWith("-" + last)) {
                        // 如果结果中最后一个VLAN已经是连续的VLAN的结束VLAN，替换为当前VLAN
                        result.replace(result.lastIndexOf(last.toString()), result.length(), vlanPool.get(index).toString());
                    } else {
                        // 否则添加连字符和当前VLAN
                        result.append("-").append(vlanPool.get(index));
                    }
                } else {
                    // 如果与上一个VLAN不连续，直接添加逗号和当前VLAN
                    result.append(",").append(vlanPool.get(index));
                }
                last = vlanPool.get(index);
            }
        }
        return result.toString();
    }
}
